home *** CD-ROM | disk | FTP | other *** search
/ Gold Medal Software 3 / Gold Medal Software - Volume 3 (Gold Medal) (1994).iso / prog / evol202a.arj / EVOLVE.DOC < prev    next >
Text File  |  1993-11-30  |  89KB  |  2,240 lines
  1.                                  EVOLVE!
  2.  
  3.  
  4. Copyright (C)  Richard H. Smith, 1993  All Rights Reserved. 
  5.  
  6.  
  7. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   1
  8.  
  9. Why programmers need to use EVOLVE!. . . . . . . . . . . . . . . . . . .   3
  10.      What is source code maintenance?. . . . . . . . . . . . . . . . . .   3
  11.      What do programmers need to maintain source code? . . . . . . . . .   4
  12.      How EVOLVE! empowers programmers to maintain source
  13.           code . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   5
  14.           What is EVOLVE!'s relation to source code
  15.                maintenance?. . . . . . . . . . . . . . . . . . . . . . .   5
  16.           How the report function transforms an outline into
  17.                source code . . . . . . . . . . . . . . . . . . . . . . .   6
  18.                "<^>" . . . . . . . . . . . . . . . . . . . . . . . . . .   6
  19.                " :> ". . . . . . . . . . . . . . . . . . . . . . . . . .   6
  20.           How to explicitly define a structure . . . . . . . . . . . . .   7
  21.                Using " :> " and "<^>" together . . . . . . . . . . . . .   9
  22.  
  23. How to use EVOLVE! . . . . . . . . . . . . . . . . . . . . . . . . . . .  11
  24.      The user interface. . . . . . . . . . . . . . . . . . . . . . . . .  11
  25.           The menu bar and menus . . . . . . . . . . . . . . . . . . . .  11
  26.           Shortcuts. . . . . . . . . . . . . . . . . . . . . . . . . . .  12
  27.           Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . .  12
  28.           The status line. . . . . . . . . . . . . . . . . . . . . . . .  12
  29.           Dialog boxes . . . . . . . . . . . . . . . . . . . . . . . . .  12
  30.      How to transform a source code file into an outline that
  31.           explicitly defines the structure of the program. . . . . . . .  13
  32.      EVOLVE!'s Script Programming Language . . . . . . . . . . . . . . .  17
  33.  
  34. Command Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . .  27
  35.      Menu structure. . . . . . . . . . . . . . . . . . . . . . . . . . .  27
  36.      Description of commands . . . . . . . . . . . . . . . . . . . . . .  29
  37.           Menu items sorted by hotkey. . . . . . . . . . . . . . . . . .  41
  38.  
  39. License Agreement. . . . . . . . . . . . . . . . . . . . . . . . . . . .  43
  40.      Definition of Shareware . . . . . . . . . . . . . . . . . . . . . .  43
  41.      Disclaimer - Agreement. . . . . . . . . . . . . . . . . . . . . . .  43
  42.      Benefits of registering . . . . . . . . . . . . . . . . . . . . . .  44
  43.      How To Register . . . . . . . . . . . . . . . . . . . . . . . . . .  45
  44.  
  45. ASP Ombudsman Statement. . . . . . . . . . . . . . . . . . . . . . . . .  47
  46.  
  47. About the Author . . . . . . . . . . . . . . . . . . . . . . . . . . . .  48
  48.  
  49.  
  50. Introduction
  51.  
  52. Mathematicians, and other technical people, sometimes talk about an
  53. abstract but simple concept they call a 'graph.'  This kind of graph
  54. is independent of any particular visual representation.  We can
  55. represent one graph an infinite number of ways.  A graph is simply
  56. a set of nodes and edges.  Each edge is a directed association of
  57. two nodes: an edge connects from one node to another node. 
  58. Sometimes these graphs are called 'nets' or 'networks.'
  59.  
  60. We can represent any information as a graph.  In particular, a
  61. computer program's source code specifies a graph, and the compiler
  62. constructs that graph while parsing the source code.  Graphs are
  63. fundamental to the way computers process information.  Any
  64. information that has a structure is an example of a graph.  
  65.  
  66. EVOLVE! is a graph tool.  It can edit graphs, generate an ASCII file
  67. that specifies the graph, and execute its own graph programming
  68. language.  The report function of EVOLVE! can generate a graph
  69. specification in a wide range of grammars.  Remember, every program
  70. is a graph specification.  I use EVOLVE! to represent parts of
  71. itself as a graph, and generate its own source code in Borland
  72. Pascal.  EVOLVE! facilitates developing and maintaining source code
  73. in any language.  It will enable a programmer to design a program
  74. such that he can efficiently implement changes, much like a
  75. programmer can use constants and macros to improve the
  76. maintainability of source code.  EVOLVE! also enables users to
  77. dynamically inspect and modify a program's structure.  The rest of
  78. this chapter will explain how EVOLVE! displays graphs.
  79.  
  80. I need to use some trivial and meaningless example of a graph to
  81. clearly explain how to best display them on a computer screen.  The
  82. example graph is 5 nodes {A,B,C,D,E} and 7 edges
  83. {AB,AC,AD,BE,CE,DE,EA}.  The previous sentence represented the graph
  84. one way by just listing the nodes and edges.  In figure 1 is another
  85. representation of the graph, where each node is represented by its
  86. name (e.g. a letter) and each edge is represented by a line.
  87.  
  88.                          ┌── >B ───┐    
  89.                          │         v  
  90.                     ┌── >A ─ >C ─ >E ─┐    
  91.                     │    │         ^  │     
  92.                     │    └── >D ───┘  │
  93.                     │                 │
  94.                     └─────────────────┘
  95.                                      
  96.                   Figure 1  An example graph
  97.  
  98. You will usually see graphs represented by a drawing where each node
  99. is represented by an ellipse or polygon containing a node identifier
  100. and each edge is represented with a line.  This is an effective
  101. format for representing a graph on paper.  We can display even large
  102. graphs this way because large pieces of paper are inexpensive and
  103. easy to acquire.
  104.  
  105. Imagine what would happen if we needed to show more text inside of
  106. each node.  Or what if we had hundreds of nodes instead of five?  We
  107. would need a lot of area to show a representation of this kind that
  108. was readable.  This works well on paper, because you can get big
  109. pieces of paper.  It does not work as well on a computer display,
  110. because they are usually only about a half page in size.
  111.  
  112. Some would argue that by using a scrollable window, a computer can
  113. display a large graph one small rectangle at a time.  Personally, I
  114. find it difficult to take in a large graph when I can only see a
  115. small part of it at once.  To clearly display large graphs on a
  116. computer screen, we need a representation that frugally uses space. 
  117. The representation shown in the figure above has a lot of unused
  118. spaced that is aesthetically pleasing but communicates little
  119. information.
  120.  
  121. The representation I prefer to use is that of a text outline.  Below
  122. is our example graph represented as a text outline
  123.  
  124.      A
  125.      1. B
  126.        1. E
  127.          1. A
  128.      2. C
  129.        1. E
  130.      3. D
  131.        1. E
  132.  
  133. With this format,  the node 'A' is listed as a child of 'E' only
  134. once because listing it under every appearance of 'E' would be
  135. redundant.  Note that we have a lot of room to the right of each
  136. node to display a full line of text.  The text outline format above
  137. has one problem: how can we know that the 'E's and 'A's are the same
  138. node, or distinct nodes with identical names?  One solution some
  139. graph representations use is to insist that each node have a unique
  140. name.  EVOLVE! does not implement this solution.  Instead, EVOLVE!
  141. displays a unique identifying number for each node that appears more
  142. than once.  Below is how EVOLVE! could display this example graph.
  143.  
  144.      A {123456789:3}
  145.      1. B
  146.        1. E {123456780:1}
  147.          1. A {123456789:3}
  148.      2. C
  149.        1. E {123456780:1}
  150.      3. D
  151.        1. E {123456780:1}
  152.  
  153. The curly brackets contain two numbers separated by a colon.  The
  154. first number is a unique identifier.  The second number is the
  155. number of edges that originate from that node.  The edge from 'E' to
  156. 'A' is only represented once, but every image of 'E' indicates that
  157. there is one edge originating from it with the ':1}'.
  158.  
  159. EVOLVE! is a graph tool that represents graphs as text outlines. 
  160. EVOLVE! is also a source code maintenance tool because source code
  161. is a graph representation, and EVOLVE! has capabilities for
  162. transforming graphs between the source code representation and the
  163. text outline representation.
  164.  
  165. Chapter 2 explains why programmers need to use EVOLVE!.  Chapter 3
  166. explains how to use EVOLVE!.  Chapter 4 is a reference section for
  167. EVOLVE!.
  168.  
  169.  
  170. Why programmers need to use EVOLVE!
  171.  
  172. Programmers need to use EVOLVE! for two reasons.  First, proper use
  173. of EVOLVE! will minimize the keystrokes and decisions required to
  174. make source code changes.  Second, programmers can use EVOLVE! to
  175. clarify their understanding of the consequences of source code
  176. changes.
  177.  
  178. This chapter provides the information a user needs to understand
  179. what EVOLVE! is and what requirements it fulfills.  This chapter's
  180. first section is a definition of source code maintenance.  The
  181. second section describes the capabilities a programmer needs to
  182. maintain source code.  The third section describes the tools, other
  183. than EVOLVE!, available for facilitating source code maintenance. 
  184. The fourth section explains the source code maintenance capabilities
  185. that only EVOLVE! provides.
  186.  
  187. What is source code maintenance?
  188.  
  189. Source code maintenance is closely related to, but not equivalent
  190. to, software maintenance.  Richard E. Fairley defines in his book
  191. "Software Engineering" software maintenance as "the software
  192. engineering activities that occur following delivery of a software
  193. product to a customer."  This could include making changes to the
  194. software that do not involve changing the source code.  You could
  195. produce a new version of an executable program by simply using a
  196. different compiler.  Also, some instances of source code maintenance
  197. are not software maintenance.  For example, a programmer may change
  198. a comment that was in error.  If the comment does not affect any
  199. deliverables to the client, this modification is source code
  200. maintenance but not software maintenance.  However, to the
  201. programmer who writes source code, software maintenance usually
  202. means changing the source code.  
  203.  
  204. The problem with the term "source code maintenance" is that it is
  205. not maintenance in the traditional sense.  Traditionally,
  206. maintenance means restoring something that is worn out.  Software
  207. does not wear out.  The American Heritage Dictionary defines
  208. maintenance as "The action of continuing, carrying on, preserving,
  209. or retaining something."  This does not describe what I think of as
  210. source code maintenance, unless the thing that source code
  211. maintenance continues, preserves, and maintains is the customer's
  212. satisfaction.  Whether the software has been delivered to the
  213. customer makes no difference to the technical challenge of changing
  214. the source in an appropriate manner.  Therefore,  I define source
  215. code maintenance as the process of evolving software by implementing
  216. appropriate incremental changes.  This process of evolving source
  217. code may occur during the development phase.
  218.  
  219. Since we know that software does not wear out, we should consider
  220. why programmers need to change source code.  There are three  types
  221. of reasons programmers change source code.  First, programmers need
  222. to correct problems.  Second, the requirements for the program may
  223. change.  Third, the development strategy may be based on
  224. incrementally evolving the program.  The point here is that
  225. programmers make incremental changes to source code in software
  226. development as well as software maintenance.
  227.  
  228. What do programmers need to maintain source code?
  229.  
  230. Programmers need the following abilities to facilitate the safe and
  231. correct maintenance of source code.
  232.  
  233.      1. The capability to modify the source code with a minimum of
  234.      keystrokes and decisions.  This reduces the probability a
  235.      programmer will introduce new errors when he makes a
  236.      modification.  For example, programmers use named constants so
  237.      that they can redefine the constant and re-compile and the
  238.      compiler will implement the new value everywhere that constant
  239.      is used.
  240.  
  241.      2. The capability to encapsulate areas of the source code to
  242.      avoid unintended side effects.
  243.  
  244.      3. The ability to inspect the code and data structures to see
  245.      the consequences of changes they are considering.
  246.  
  247.  
  248. How EVOLVE! empowers programmers to maintain source code
  249.  
  250. EVOLVE! lets users program down to the lowest level of detail with
  251. a structure editor.  It enables users to change and dynamically
  252. inspect a program's structure.  When a programmer uses EVOLVE! to
  253. explicitly define the programs structure, she has at her disposal
  254. hypertext like links she can use to inspect the source code.
  255.  
  256. This section answers the following questions:
  257.  
  258.      1. What is EVOLVE!'s relation to source code maintenance?
  259.  
  260.      2. How does the report function transform an outline into
  261.      source code?
  262.  
  263.      3. How can a programmer use EVOLVE! to explicitly represent the
  264.      structure of a program as an outline?
  265.  
  266. What is EVOLVE!'s relation to source code maintenance?
  267. ======================================================
  268.  
  269. EVOLVE! is in one way the complement of source code.  Source code is
  270. always a sequence of symbols that define a structure.  The structure
  271. defined by source code includes data structures, machine
  272. instructions, compiler directives, and comments to the reader of the
  273. source code.  EVOLVE! is a structure editor that produces source
  274. code.  It enables you to edit the structure as a hierarchy (a.k.a.
  275. outline), and produce source code from that hierarchy.  Although
  276. EVOLVE! displays the program as an outline while a user edits it, he
  277. can press a key to instantly view the program as source code.
  278.  
  279. When programmers use a text editor to create and modify a source
  280. code file, they use the syntax of the language and the
  281. identifiers they create to specify a structure that the compiler
  282. will understand and process into machine language.  When a
  283. programmer uses EVOLVE!, he explicitly defines a structure 
  284. (visually represented on the screen as an outline) that the EVOLVE!
  285. program processes to produce a text file of source code that
  286. specifies the explicitly defined structure.  If the programmer
  287. creates a structure with EVOLVE!, he can use this structure to
  288. perform the following source code maintenance functions:
  289.  
  290.      1. Efficiently implement changes without introducing new
  291.      errors. 
  292.  
  293.      2. Dynamically inspect the structure of the code to evaluate
  294.      the consequences of possible modifications.
  295.  
  296. How the report function transforms an outline into source code
  297. ==============================================================
  298.  
  299. The report command under the files menu will generate source code
  300. from an outline by processing two special strings.  The first string
  301. is "<^>" and the second string is " :> ".  Programmers use the " :>
  302. " string to define the syntactic structure and the "<^>" string to
  303. define part of the semantic structure.  
  304.  
  305. "<^>"
  306.  
  307. When a user chooses to produce a report, EVOLVE! processes the "<^>"
  308. string first by replacing each one with the text from a subsidiary
  309. line in the outline.  Below is an example of how the report function
  310. processes "<^>":
  311.  
  312.      The <^> is <^>.
  313.        car
  314.        green
  315.        The end.
  316.  
  317. The outline above would produce the following report:
  318.  
  319.      The car is green.
  320.        The end.
  321.  
  322. Notice that EVOLVE! accounts for how many subsidiary lines were used
  323. to replace "<^>", and processes the rest.
  324.  
  325. " :> "
  326.  
  327. The " :> " string is used to define delimiters.  Many programming
  328. languages will use a comma or semicolon in between items in a list,
  329. and a special string to mark the end like '}', ')', or 'end'.  You
  330. can use " :> " twice in one line: first to specify the in between
  331. delimiter and second occurrence of " :> " to define the ending
  332. delimiter.  Below is an example:
  333.  
  334.      MyFunc( :> , :> )
  335.        aaa
  336.        bbb
  337.        ccc
  338.  
  339. The outline above would produce the following report:
  340.  
  341.      MyFunc(
  342.        aaa,
  343.        bbb,
  344.        ccc)
  345.  
  346. How to explicitly define a structure
  347. ====================================
  348.  
  349. Users will want to create an outline where an identifier appears in
  350. more than one place.  The best way to do this is to place each
  351. identifier on a separate line and use '<^>' to place the identifier
  352. in the "parent" line of the outline.  The reason users should place
  353. each identifier on a separate line is that they can reference a
  354. line.  Users should not simply retype or copy identifiers because
  355. that creates new instances of the identifier.  The new line created
  356. by a copy is distinct from the originals.  The "mark" and
  357. "reference" commands enable users to create another appearance of a
  358. line, where both the original appearance and the new appearance
  359. refer to the same instance of the line.  When a user makes a change
  360. to a line that appears in more than one place (because it is
  361. referenced) the change is implemented at all locations.  A user can
  362. create a new appearance of a line by:
  363.  
  364.      1. If any lines are already marked, press [Alt-U] to unmark all
  365.      lines.
  366.  
  367.      2. "mark" the line(s).
  368.  
  369.      3. move the cursor to the parent of the new appearance(s).
  370.  
  371.      4. press [Alt-=] to "reference" the marked line(s).
  372.  
  373. There are three ways to mark a line:
  374.  
  375.      1. Users can mark an unmarked line and unmark a marked line by
  376.      double clicking the left mouse button.
  377.  
  378.      2. Users can mark the next (or previous) line with a specified
  379.      substring.  The command for this is named "Mark if found" and
  380.      its hot key is [Ctrl-F6].  
  381.  
  382.      3. Users can position the cursor on a line and press [Alt-V] to
  383.      mark an unmarked line and unmark a marked line. 
  384.  
  385. Appearances of a referenced line identify themselves by displaying
  386. a unique number, followed by the number of children they have.  It
  387. looks like this:
  388.  
  389.      a referenced line {1234567890:5}
  390.  
  391. If a programmer references an identifier where it makes sense, she
  392. will benefit in the following ways:
  393.  
  394.      1. She can use the "Go to parent" command [F7] to see a list of
  395.      everywhere that identifier is used in the source code.  
  396.  
  397.  
  398.        File  Relocate items  Move cursor  Edit  Marking  Window             03:00:26
  399.      ╔═[■]════════════════════════════ Go to parent ════════════════════════════════╗
  400.      ║ 5 FirstNumber : Integer {The first number}                                  ║
  401.      ║ 8 SecondNumber : Integer {The second number}                                ▒║
  402.      ║ 11 MyResult : Integer {The answer}                                          ▒║
  403.      ║ 16 OneNumber : Integer                                                      ▒║
  404.      ║ 19 AnotherNumber : Integer                                                  ▒║
  405.      ║ 14 Function MultiplyTwoNumbers(OneNumber : Integer;AnotherNumber : Integer) ▒║
  406.      ║                                                                             ▒║
  407.      ║                                                                             ▒║
  408.      ║                                                                             ▒║
  409.      ║                                                                             ▒║
  410.      ║                                                                             ■║
  411.      ║                                                                             ▒║
  412.      ║                                                                             ▒║
  413.      ║                                                                             ▒║
  414.      ║                                                                             ▒║
  415.      ║                                                                             ▒║
  416.      ║                                                                             ▒║
  417.      ║                                                                             ║
  418.      ║                                                                              ║
  419.      ║       Ok    ▄       Cancel  ▄                                                ║
  420.      ║    ▀▀▀▀▀▀▀▀▀▀      ▀▀▀▀▀▀▀▀▀▀                                                ║
  421.      ╚══════════════════════════════════════════════════════════════════════════════╝
  422.       F1 Help  F3 Open  Alt-F3 Close  F5 Zoom                                5841616
  423.  
  424.  
  425.      2. Any change he makes to one appearance of an identifier is
  426.      implemented at all appearances of that identifier.
  427.  
  428. Using " :> " and "<^>" together
  429.  
  430. Below is an example Pascal program that reads two numbers and prints
  431. out their product:
  432.  
  433. Program MultiplyTwo;
  434.   {This program reads in two numbers and prints the product}
  435.     Var
  436.       FirstNumber : Integer {The first number};
  437.       SecondNumber : Integer {The second number};
  438.       MyResult : Integer {The answer};
  439.   Function MultiplyTwoNumbers(OneNumber : Integer;AnotherNumber :
  440. Integer) : Integer;
  441.     begin
  442.       MultiplyTwoNumbers := 
  443.         OneNumber * 
  444.         AnotherNumber;
  445.       end;
  446.   begin
  447.     readln(
  448.       FirstNumber,
  449.       SecondNumber);
  450.     MyResult := MultiplyTwoNumbers(
  451.       FirstNumber,
  452.       SecondNumber);
  453.     writeln(
  454.       'The first: ',
  455.       FirstNumber,
  456.       ' The Second: ',
  457.       SecondNumber,
  458.       ' The Product: ',
  459.       MyResult);
  460.     end.
  461.  
  462. EVOLVE! will generate this program source code from the following
  463. outline:
  464.  
  465. Program MultiplyTwo; :> ; :> .
  466.   {<^>}
  467.     This program reads in two numbers and prints the product
  468.     Var :> ;
  469.       <^> : <^> {The first number}
  470.         FirstNumber {18269:0}
  471.         Integer {18274:0}
  472.       <^> : <^> {The second number}
  473.         SecondNumber {18287:0}
  474.         Integer {18274:0}
  475.       <^> : <^> {The answer}
  476.         MyResult {18302:0}
  477.         Integer {18274:0}
  478.   Function <^>(<^>;<^>) : <^>;
  479.     MultiplyTwoNumbers {18318:0}
  480.     <^> : <^>
  481.       OneNumber {18331:0}
  482.       Integer {18274:0}
  483.     <^> : <^>
  484.       AnotherNumber {18346:0}
  485.       Integer {18274:0}
  486.     Integer {18274:0}
  487.     begin :> ; :> end
  488.       <^> := :> * 
  489.         MultiplyTwoNumbers {18318:0}
  490.         OneNumber {18331:0}
  491.         AnotherNumber {18346:0}
  492.       
  493.   begin :> ; :> end
  494.     readln( :> , :> )
  495.       FirstNumber {18269:0}
  496.       SecondNumber {18287:0}
  497.     <^> := <^>( :> , :> )
  498.       MyResult {18302:0}
  499.       MultiplyTwoNumbers {18318:0}
  500.       FirstNumber {18269:0}
  501.       SecondNumber {18287:0}
  502.     writeln( :> , :> )
  503.       'The first: '
  504.       FirstNumber {18269:0}
  505.       ' The Second: '
  506.       SecondNumber {18287:0}
  507.       ' The Product: '
  508.       MyResult {18302:0}
  509.  
  510. The above outline explicitly defines the structure of the program. 
  511. When a programmer, using EVOLVE!, has an outline with an explicitly
  512. defined structure he can efficiently manage the source code changes. 
  513. He can also use the outline to dynamically inspect the program's
  514. structure to evaluate the consequences of possible changes.
  515.  
  516. The reader should not let the size of the above outline mislead him
  517. to think that it takes more keystrokes to build the outline than to
  518. type the source code.  The "Marking" commands let users reference an
  519. identifier with fewer keystrokes than it takes to type it.
  520.  
  521. To summarize this section, EVOLVE! is a source code structure
  522. editor.  The user can "mark" and "reference" identifiers to
  523. explicitly define part of the semantic structure.  The user can
  524. define the rest of the semantic structure with the "<^>"
  525. character.  When the user invokes the "report" function, EVOLVE!
  526. replaces each "<^>" with the text of a child in the outline.  The
  527. user can define some of the syntactic structure with the " :> "
  528. string.  Together, the syntactic and semantic structures comprise
  529. the structure of the program's source code.  EVOLVE! enables users
  530. to explore and edit a program's structure explicitly and
  531. dynamically. 
  532.  
  533. How to use EVOLVE!
  534.  
  535. This chapter explains how to use EVOLVE!.  The first section
  536. describes general features of the user interface.  The second
  537. section gives an example of how to transform a source code  file
  538. into an outline.  The third section explains the macro-programming 
  539. language.
  540.  
  541. The user interface
  542.  
  543. EVOLVE!'s user interface has the general features common to most
  544. modern software programs.  These general features are pull down
  545. menus, shortcuts, windows, status line, and dialog boxes.
  546.  
  547. The menu bar and menus
  548. ======================
  549.  
  550. The menu bar is your primary access to all the menu commands. 
  551. You'll see a highlighted menu title when the menu bar is active;
  552. this is the currently selected menu.  Here is how you choose menu
  553. commands using just the keyboard:
  554.  
  555. 1. Press [F10].  This makes the menu bar active.
  556.  
  557. 2. Use the arrow keys to select a sub-menu to display.  Then press
  558. [Enter].
  559.  
  560. As a shortcut to this step, a user can just press the highlighted
  561. letter of the sub-menu title.  For example, from the menu bar,
  562. press [F] to quickly display the file menu.  From anywhere, press
  563. [Alt] and the highlighted letter to display the menu you want.
  564.  
  565. 3.  Use the arrow keys again to select the command desired.  Then
  566. press [Enter]. 
  567.  
  568. Again, as a shortcut, users can just press the highlighted letter
  569. of a command to choose it once the menu is displayed.
  570.  
  571. At this point, EVOLVE! either carries out the command, displays a
  572. dialog box, or displays another menu.
  573.  
  574. Shortcuts
  575. =========
  576.  
  577. A user can access many items in the menus with key combinations
  578. called shortcuts.  These key combinations are shown to the right
  579. of the menu item in the menu boxes, and to the left of the command
  580. in the status line.  On page 41 there begins a list of menu items
  581. and their associated shortcuts.  This list is sorted by shortcut
  582. key.
  583.  
  584. Windows
  585. =======
  586.  
  587. Windows in EVOLVE! have the following:
  588.  
  589.      1. A title at the center of the top border.  The title is the
  590.      name of the file associated with the window.
  591.  
  592.      2. A window number.  You can quickly select a window by
  593.      pressing [Alt] and the number of the window.
  594.  
  595.      3. Horizontal and vertical scroll bars to show you the
  596.      location of your view into a virtual screen.
  597.  
  598.      4. A position indicator at the left of the lower window
  599.      border that displays the row and column of the cursor.
  600.  
  601.      5. A 'splat' character that appears to the left of the
  602.      position indicator when you have changed the program since
  603.      the last save.
  604.  
  605. The status line
  606. ===============
  607.  
  608. The status line appears at the bottom of the screen.  It reminds
  609. you of basic keystrokes and shortcuts applicable at that moment in
  610. the active window.
  611.  
  612. Dialog boxes
  613. ============
  614.  
  615. When a user is making settings in dialog boxes, they work with
  616. four basic types of on-screen controls: radio buttons, action
  617. buttons, input boxes, and list boxes.
  618.  
  619. Users can use [Tab] to select the next control in the dialog box
  620. and [Shift-Tab] to select the previous control in the dialog. 
  621. Most controls have labels with one letter highlighted.  Users can
  622. select a control object by pressing [Alt] and the highlighted
  623. letter.  Users can close the dialog box by either selecting the
  624. "OK" button to accept the data in the box and press [Enter], or
  625. cancel any action by the box by pressing [Escape] or selecting a
  626. "Cancel" button and pressing return.  
  627.  
  628. Radio buttons work like the buttons on a radio; they represent
  629. mutually exclusive choices.  Use [Tab] or [Shift-Tab] to select
  630. the group of radio buttons.  Then select the item you want with
  631. the up and down arrow keys and press [Space] to toggle that item. 
  632. Toggling a radio button untoggles the previously toggled button. 
  633. Input boxes are fields where text is entered and edited.  
  634.  
  635. Most basic text editing keys work in the text box.  If an input
  636. box has a down-arrow icon to its right, there is a history list
  637. associated with the input box.  Press [Down Arrow] to view the
  638. history list and enter to select an item from the list.  This
  639. list will display any text you typed into the box the last few
  640. times you used it.  Users can edit any item in the history list. 
  641. Press [Escape] to exit the history list without making a
  642. selection.
  643.  
  644. A final component of many dialog boxes is a list box.  A list box
  645. lets you scroll through and select from variable-length lists
  646. without leaving a dialog box.  If a blinking cursor appears in the
  647. list box and the user knows what he is looking for, he can type
  648. the first letters of the text and the listbox will search for it. 
  649. He can move through the list with [Up Arrow] and [Down Arrow].
  650.  
  651. How to transform a source code file into an outline that
  652. explicitly defines the structure of the program
  653.  
  654. This section is an example of how to transform the source code of
  655. a program into an outline in EVOLVE!.
  656.  
  657.      1. Press return at the opening screen to get rid of it.
  658.  
  659.      2. Press [Ctrl-F8] to import an ASCII file.
  660.  
  661.      3. Select the name of a file already on the disk.
  662.  
  663.      4. Press [F9] to save the outline as a file with a different
  664.      extension, preferably ".MNT".
  665.  
  666.      5. Press [Alt-X] to exit.
  667.  
  668. A programmer should be able to produce source code from this
  669. outline now by pressing [Ctrl-F7], which invokes the report to
  670. file function.
  671.  
  672. The outline as it stands now does not explicitly define the
  673. structure of the program.  You can transform the outline into an
  674. explicit representation of the source code structure through a
  675. range of strategies.  This range of strategies is bounded by two
  676. extremes:  all at once, or as needed.
  677.  
  678. This section first discusses defining the semantic structure
  679. explicitly, and then defining the syntactic structure explicitly. 
  680. An explicitly defined semantic structure will enable users to gain
  681. the full utility of the "Go to parent" command, [F7].  This
  682. command will let you see all the lines of source code that use a
  683. given identifier.  For example, the screen below shows the parents
  684. of the identifier 'INTEGER' in the outline file PROG1.MNT.
  685.  
  686.   File  Relocate items  Move cursor  Edit  Marking  Window             03:00:26
  687. ╔═[■]════════════════════════════ Go to parent ════════════════════════════════╗
  688. ║ 5 FirstNumber : Integer {The first number}                                  ║
  689. ║ 8 SecondNumber : Integer {The second number}                                ▒║
  690. ║ 11 MyResult : Integer {The answer}                                          ▒║
  691. ║ 16 OneNumber : Integer                                                      ▒║
  692. ║ 19 AnotherNumber : Integer                                                  ▒║
  693. ║ 14 Function MultiplyTwoNumbers(OneNumber : Integer;AnotherNumber : Integer) ▒║
  694. ║                                                                             ▒║
  695. ║                                                                             ▒║
  696. ║                                                                             ▒║
  697. ║                                                                             ▒║
  698. ║                                                                             ■║
  699. ║                                                                             ▒║
  700. ║                                                                             ▒║
  701. ║                                                                             ▒║
  702. ║                                                                             ▒║
  703. ║                                                                             ▒║
  704. ║                                                                             ▒║
  705. ║                                                                             ║
  706. ║                                                                              ║
  707. ║       Ok    ▄       Cancel  ▄                                                ║
  708. ║    ▀▀▀▀▀▀▀▀▀▀      ▀▀▀▀▀▀▀▀▀▀                                                ║
  709. ╚══════════════════════════════════════════════════════════════════════════════╝
  710.  F1 Help  F3 Open  Alt-F3 Close  F5 Zoom                                5841616
  711.  
  712.  
  713. The all at once strategy, for the semantic structure, is to
  714. start at the top of the outline and perform the
  715. "Search,Extract,Mark/Reference" command for each identifier.  This
  716. command is found in the "Marking" menu.  A programmer can use this
  717. command interactively through the menus, or in a script program.
  718.  
  719. Steps for using a script program:
  720.  
  721.      1. Create a list of identifiers to reference.  I have
  722. provided a program for creating a list of identifiers found in a
  723. Borland Pascal program.  The file TOKENIZE.EXE is this program. 
  724. The directions for using it are in TOKENIZE.DOC.
  725.  
  726.      2. Put your list into an outline with the 'ASCII Text Import'
  727. menu choice from the 'Files' menu.
  728.  
  729.      3.  Delete any identifiers you do not want to reference.
  730.  
  731.      4. Write a script program like the example below to read in a
  732. list of text files and reference the identifiers.  The example
  733. below is the file TXT2OUT.MNT.  You can execute the script by
  734. placing the cursor on the second line and pressing [Alt-F10].
  735.  
  736. {Root}
  737. |-DoAll
  738. | |-@ <^>
  739. | | |-Read in each source code file {45029428:2}
  740. | | | |-A File Name {45029532:0}
  741. | | | `-DoAll
  742. | | |   |-cmFirstLine
  743. | | |   |-cmGoToKid
  744. | | |   | `-1
  745. | | |   `-cmTroper
  746. | | |     `-A File Name {45029532:0}
  747. | | `-Multiply.pas
  748. | |-@ <^>
  749. | | |-Read in each source code file {45029428:2}
  750. | | `-MultTwo.pas
  751. | `-DoAll
  752. |   |-cmFirstLine
  753. |   |-cmGoToKid
  754. |   | `-1
  755. |   `-cmRefSearch
  756. |     |-ANOTHERNUMBER
  757. |     | |-FIRSTNUMBER
  758. |     | |-INTEGER
  759. |     | |-MULTIPLY
  760. |     | |-MULTIPLYTWONUMBERS
  761. |     | |-MYRESULT
  762. |     | |-ONENUMBER
  763. |     | `-SECONDNUMBER
  764. |     |-0 Direction
  765. |     |-1 Options
  766. |     `-0 End of scope
  767. `-
  768.  
  769.  
  770. This user's guide explains the details of the script language in
  771. chapter 4 section 3 and chapter 5.
  772.  
  773. There is another strategy that may be more practical for some
  774. cases.  A programmer  can transform the outline a little at a time
  775. as he needs it.  When he has to make a source code modification,
  776. he performs the steps specified above, but only for the
  777. identifiers relevant to the source code modification.
  778.  
  779. An explicitly defined syntactic structure is useful, but not as
  780. useful as an explicitly defined semantic structure.  The syntactic
  781. structure is defined with the " :> " string.  Languages like C and
  782. Pascal use special syntax to delimit lists of things.  In Pascal,
  783. each invocation of a function that takes parameters must include a
  784. list of parameters to pass to that function.  This list of
  785. parameters in the invocation begins with a left parenthesis, ends
  786. with a right parenthesis, and separates each item in the list with
  787. a comma.  I do not recommend a programmer explicitly define the
  788. syntactic structure of a function call with " :> " if it is fully
  789. contained in one line of text.  However, there are some cases
  790. where function calls are nested to form a hierarchy.  Some user
  791. interface tools encourage programmers to define menu structures
  792. this ways.  The syntax can get difficult to manage.  A programmer
  793. can use the " :> " string most efficiently for that case.  I
  794. suggest programmers start at the deepest levels of the outline and
  795. look for places they can extract the syntax to the parent line.
  796.  
  797. In short, the way to transform a source code file is to import it
  798. as an ASCII file, then use the 'Search, Extract, Mark/Reference'
  799. command on identifiers.
  800. EVOLVE!'s Script Programming Language
  801.  
  802. Sometimes a users finds herself performing a similar sequence of
  803. commands through the use of menus or hotkeys.  Users can sometimes
  804. automate these sequences of commands by using a script program. 
  805. These scripts are outlines themselves, where each line is either a
  806. script command, an expression, or a data item.  You can execute
  807. any part of an outline as a script by placing the cursor on the
  808. first line of the script and pressing [Alt-F10].
  809.     
  810. Most of the menu items that operate within the context of just one
  811. window have an equivalent script command.  For example, the 'Move
  812. cursor' menu has an item 'to first line' that performs the same
  813. function as the script command 'cmFirstLine'.  Another example is
  814. the 'Go to line number' menu item which is equivalent to the
  815. script command 'cmGoToLine'.  This script command looks for the
  816. line number in the first child of its line.  All the script
  817. commands that are similar to menu items are outline script
  818. commands.  This user's guide explains each outline script command
  819. with its corresponding menu item in the user interface reference.
  820.  
  821. EVOLVE! augments the power of the outline script commands with
  822. data flow script commands and control flow script commands.  Data
  823. flow script commands evaluate expressions and move the result to
  824. other lines.  Control flow commands control the sequence in which
  825. EVOLVE! executes the script commands.
  826.  
  827. The data flow commands are: 
  828.  
  829.      cmMoveOutlineData 
  830.      cmMoveOutlineNumber 
  831.      cmMoveProgramData 
  832.      cmMoveProgramNumber
  833.      cmMoveProgram2Outline
  834.  
  835. The cmMoveOutlineData and cmMoveOutlineNumber act on the outline
  836. with out affecting the script as it is currently executing.  When
  837. you execute part of an outline as a script, EVOLVE! first makes a
  838. copy of the script so any changes the script makes to the outline
  839. will not accidentally interfere with the script.  This copy is
  840. executed as the script program and deleted at the end of the
  841. script's execution.  At the moment of replication, the script's
  842. current instruction corresponds to the outline's current line. 
  843. However, after replication the script and the outline are 
  844. separate and independent.  Thus, we can write script's that safely
  845. alter the outline without accidentally interfering with the
  846. script's execution.  
  847.  
  848. These 'cmMoveOutline...' commands act on the children of the
  849. current line in the outline.  They take information from the first
  850. child and pass the information to all other children of the
  851. current line.  Likewise, the cmMoveProgramNumber and
  852. cmMoveProgramData affect the script that is currently executing,
  853. and will not affect the outline.  These commands act on the
  854. children of the current instruction in the script.  They both
  855. transfer data from the first child of the current instruction to
  856. all other children of the current instruction.  The
  857. cmMoveProgram2Outline command transfers data from the current
  858. instruction to the outline's current line.
  859.  
  860. The commands that end with the word 'Number' evaluate the first
  861. child as a real number expression.  A real number expression is
  862. simply a real number or an expression that produces a real number. 
  863. Below is a list of expression that produce a real number.
  864.  
  865.      +    Sum all children of the this script line
  866.      -    Negate and sum all children of this script line
  867.      /    divide the first child of this script line by the
  868.           product of all other children 
  869.      *    multiply all children of this script line
  870.      ?    the position of the outline's current line among its
  871.           siblings, less one.  If the outline's current line is
  872.           the first child of its parent, it returns 0.  If the
  873.           outline's current line is the second child of its
  874.           parent, it returns 1.  Etc...
  875.      #    the number of children under the outline's current line
  876.      <=>  compares the first two children of this script line as
  877.           numeric expressions.
  878.  
  879.                Result    Meaning
  880.                =============================================
  881.                1         First child is less than second
  882.                2         First and second child are equal
  883.                3         Second child is less than the first child
  884.                4         There is an error
  885.  
  886.      ==   This test to see if all the children of the outline's
  887.           current line are references of the same line.  If two 
  888.           lines are references of the same line they will have the
  889.           same two numbers inside of curly brackets to the right
  890.           of their text.
  891.  
  892.                Result    Meaning
  893.                ====================
  894.                1         all reference the same line
  895.                2         not all the same
  896.                3         Error
  897.  
  898.      =    test to see if the text in each child of this script
  899.           line the are all equal
  900.  
  901.                Result    Meaning
  902.                =============================================
  903.                1         First child is less than second
  904.                2         First and second child are equal
  905.                3         Second child is less than the first child
  906.                4         There is an error
  907.  
  908.  
  909.      @    invokes a user defined function which is identified by      
  910.      the first child of the line containing '@'.  The siblings of
  911.      '@' which follow it are parameters passed to the user defined
  912.      function.  The children of the first child of '@' (the first
  913.      group of '@' grandchildren) define the function.  The last
  914.      grandchild of the first group of '@' grandchildren should be
  915.      an expression that produces a real number.  The other
  916.      grandchildren in that group are parameters passed to the user
  917.      defined function.  For example:
  918.  
  919.      DoOne
  920.      |-@                      
  921.      | |-MyFunction
  922.      | | |-X {45029440:0}
  923.      | | |-Y {45029492:0}
  924.      | | `-+
  925.      | |   |-X {45029440:0}
  926.      | |   `-Y {45029492:0}
  927.      | |-1
  928.      | `-1
  929.      |-cmLastLine
  930.      `-cmFirstLine
  931.  
  932.      In the example above, X and Y are parameters of the user
  933.      defined function identified by  'Myfunction'.  This trivial
  934.      example of a user defined function merely adds numbers
  935.      together.  In this case, 1 + 1 = 2.  So the '@' is evaluated
  936.      to be 2, and the 'cmFirstLine' command is executed by the
  937.      DoOne command.
  938.  
  939.      When the script processor executes the function, it first
  940.      copies values to the parameters.  If the function is written
  941.      to receive N parameters, the script processor copies up to N
  942.      values to the parameters.  Then the script processor
  943.      calculates the expression, and places the value of the result
  944.      in the first parameter.  Then the script processor looks for
  945.      more unprocessed values passed to the function, and takes up
  946.      to N-1 values, writing the values to the second parameter up
  947.      to the Nth parameter.  The script processor calculates the
  948.      expression again.  The script will continue to pass all
  949.      parameters given to the function, using the first parameter
  950.      as an accumulator.
  951.  
  952. The commands that end with the word 'data' process the first child
  953. as a text expression.  A text expression is simply a line of text
  954. or an expression that produces a line of text.  Each occurrence of
  955. the string <^> is replaced with the text produced by a child.  The
  956. first occurrence is replaced by the text produced by the first
  957. child.  The second occurrence is replaced by the text produced
  958. from the second child, and so forth.  
  959.  
  960.  
  961. Example 1 of cmMoveOultineData:
  962.  
  963. Before execution
  964.  
  965.      cmMoveOutlineData  This is the first line, place cursor here
  966.      1. Hello world.
  967.      2.
  968.  
  969. After execution
  970.  
  971.      cmMoveOutlineData  This is the first line, place cursor here
  972.      1. Hello world.
  973.      2. Hello world.
  974.  
  975. Example 2 of cmMoveOutlineData with a text expression
  976.  
  977. Before execution
  978.  
  979.      cmMoveOutlineData
  980.      1. <^> <^>.
  981.        1. Hello
  982.        2. world
  983.      2.
  984.  
  985. After execution
  986.  
  987.      cmMoveOutlineData
  988.      1. <^> <^>.
  989.        1. Hello
  990.        2. world
  991.      2. Hello world.
  992.  
  993. Example 3 cmMoveOutlineNumber
  994.  
  995. Before execution
  996.  
  997.      cmMoveOutlineNumber
  998.      1. 5.5
  999.      2.
  1000.  
  1001. After execution
  1002.  
  1003.      cmMoveOutlineNumber
  1004.      1. 5.5
  1005.      2. 5.5000000000E+00
  1006.  
  1007. Example 4 cmMoveOutlineNumber with an expression
  1008.  
  1009. Before execution
  1010.  
  1011.      cmMoveOutlineNumber
  1012.      1. +
  1013.        1. 2.3
  1014.        2. 3.2
  1015.      2.
  1016.  
  1017. After execution
  1018.  
  1019.      cmMoveOutlineNumber
  1020.      1. +
  1021.        1. 2.3
  1022.        2. 3.2
  1023.      2. 5.5000000000E+00
  1024.  
  1025. The cmMoveProgramData and cmMoveProgramNumber commands are similar
  1026. but they do not affect the outline.  These commands perform
  1027. similar functions on the script program.
  1028.  
  1029. The command cmMoveProgram2Outline will evaluate the first child of
  1030. the current instruction as a text expression, and set the current
  1031. line in the outline to that result.
  1032.  
  1033. The control flow commands are: DoAll, DoOne, Loop, and Pop.  
  1034.  
  1035. DoAll will execute each child of the current instruction as a
  1036. command.  
  1037.  
  1038. DoOne will evaluate the first child of the current instruction as
  1039. an expression that produces a number.  The result of the first
  1040. child of the current instruction indicates which child, if any,
  1041. will succeed it as the current instruction.  The Nth child of
  1042. DoOne is executed if N is the lowest upper bound of the numeric
  1043. result from the first child.  If the first child is the value 5
  1044. then the sixth child will execute next.  After the sixth child
  1045. executes, the next instruction will be the sibling following the
  1046. DoOne command.  In other words, the script will not execute more
  1047. than one child of a DoOne instruction.
  1048.  
  1049. Loop, like DoAll, will execute each child as a command.  In
  1050. addition, Loop will repeat itself by starting with the first child
  1051. again after the last child is executed.  
  1052.  
  1053. The only way to stop the Loop cycle is with a Pop command.  Pop
  1054. will exit out of the current Loop.  Pop will also exit out of a
  1055. DoAll.  When Loop's and DoAll's are nested, Pop will exit out of
  1056. the last DoAll or Loop that the EVOLVE! script is still
  1057. processing.
  1058.  
  1059. There is one last command which is both a control flow and a data
  1060. flow command.  This command is '@' (without the quotes) and
  1061. executes a user defined procedure.  The first line under the @
  1062. identifies the procedure.  The child lines of the identifying line
  1063. are the parameters and the body of the procedure.  The last child
  1064. line of the identifier is the body, and is usually 'DoAll' with
  1065. child commands of its own.  The lines under the @ other than the
  1066. first line are the values that are passed to the parameters of the
  1067. user defined procedure.
  1068.  
  1069. For example, let us look at a user defined procedure from the
  1070. example script for converting source code files into an outline.
  1071.  
  1072. | |-@ <^>
  1073. | | |-Read in each source code file {45029428:2}
  1074. | | | |-A File Name {45029532:0}
  1075. | | | `-DoAll
  1076. | | |   |-cmFirstLine
  1077. | | |   |-cmGoToKid
  1078. | | |   | `-1
  1079. | | |   `-cmTroper
  1080. | | |     `-A File Name {45029532:0}
  1081. | | `-Multiply.pas
  1082.  
  1083. When the script execution reaches the line with the '@', it copies
  1084. the text from the second child ('Multiply.pas') to the first child
  1085. of the identifying line ('A File Name').  Then the script
  1086. processor executes the body of the procedure ('DoAll').
  1087.  
  1088. The user can execute any part of an outline as a script by placing
  1089. the cursor on the first line of the script and pressing [Alt-F10]. 
  1090. Each line in the script can be one command or data item.  Any text
  1091. to the right of a script command in a line is ignored, so we may
  1092. use this space to place comments.  A script command can be a
  1093. control flow command, data flow command, a procedure call, or an
  1094. outline command.  The control flow commands direct the order in
  1095. which script instructions take their turn as the current
  1096. instruction.  Data Flow commands move information through the
  1097. outline and the script.  Procedure calls are both a control flow
  1098. and a data flow command.  The outline script commands act on the
  1099. outline, and they correspond to a similar menu command.  The
  1100. script outline commands are a subset of the commands available
  1101. through the EVOLVE! menu.  The reference section documents each
  1102. script outline command with its corresponding menu item.  
  1103.  
  1104. The following examples use the data flow, control flow and outline
  1105. commands listed in this chapter.
  1106.  
  1107. Before execution 
  1108.  
  1109. Example 7
  1110. `-DoAll add lines with numbers in them
  1111.   `-Loop through this
  1112.     |-DoOne
  1113.     | |-<=>
  1114.     | | |-0 count {48173600:0}
  1115.     | | `-5
  1116.     | |-cmAddSibling makes a new blank line below this script
  1117.     | `-Pop out of this loop
  1118.     |-cmMoveProgramNumber  This increments the loop counter
  1119.     | |-+
  1120.     | | |-1
  1121.     | | `-0 count {48173600:0}
  1122.     | `-0 count {48173600:0}
  1123.     `-cmProgram2Outline  sends the value of count to new line
  1124.       `-0 count {48173600:0}
  1125.  
  1126. After execution 
  1127.  
  1128. Example 7
  1129. |-DoAll add lines with numbers in them
  1130. | `-Loop through this
  1131. |   |-DoOne
  1132. |   | |-<=>
  1133. |   | | |-0 count {48173600:0}
  1134. |   | | `-5
  1135. |   | |-cmAddSibling makes a new blank line below this script
  1136. |   | `-Pop out of this loop
  1137. |   |-cmMoveProgramNumber  This increments the loop counter
  1138. |   | |-+
  1139. |   | | |-1
  1140. |   | | `-0 count {48173600:0}
  1141. |   | `-0 count {48173600:0}
  1142. |   `-cmProgram2Outline  sends the value of count to new line
  1143. |     `-0 count {48173600:0}
  1144. |- 1.0000000000E+00
  1145. |- 2.0000000000E+00
  1146. |- 3.0000000000E+00
  1147. |- 4.0000000000E+00
  1148. `- 5.0000000000E+00
  1149.  
  1150.  
  1151.  
  1152. An example script file (OUT2TXT.MNT) to generate two source code
  1153. files from one outline.
  1154.  
  1155. |-DoAll
  1156. | |-cmFirstLine {46074960:0}
  1157. | |-cmGoToKid
  1158. | | `-1
  1159. | |-cmReport
  1160. | | `-<^>.PAS
  1161. | |   `-Multiply {46075316:0}
  1162. | |-cmFirstLine {46074960:0}
  1163. | |-cmGoToKid
  1164. | | `-2
  1165. | `-cmReport
  1166. |   `-<^>.PAS
  1167. |     `-MultTwo {46075752:0}
  1168. |-Unit <^>; :>   :> .
  1169. | |-Multiply {46075316:0}
  1170. | |-interface
  1171. | | `-Function <^>(<^>;<^>) : <^>; {46076148:5}
  1172. | `-implementation
  1173. |   |-Function <^>(<^>;<^>) : <^>; {46076148:5}
  1174. |   | |-MultiplyTwoNumbers {46076256:0}
  1175. |   | |-<^> : <^>
  1176. |   | | |-OneNumber {46076420:0}
  1177. |   | | `-Integer {46076488:0}
  1178. |   | |-<^> : <^>
  1179. |   | | |-AnotherNumber {46076640:0}
  1180. |   | | `-Integer {46076488:0}
  1181. |   | |-Integer {46076488:0}
  1182. |   | `-begin :> ; :> end;
  1183. |   |   |-<^> := :> * 
  1184. |   |   | |-MultiplyTwoNumbers {46076256:0}
  1185. |   |   | |-OneNumber {46076420:0}
  1186. |   |   | `-AnotherNumber {46076640:0}
  1187. |   |   `-
  1188. |   |-begin
  1189. |   `-end
  1190. `-Program <^>; :> ; :> .
  1191.   |-MultTwo {46075752:0}
  1192.   |-{<^>}
  1193.   | |-This program reads in two numbers and prints the product
  1194.   | |-Uses Multiply;
  1195.   | `-Var :> ;
  1196.   |   |-<^> : <^> {The first number}
  1197.   |   | |-FirstNumber {46077844:0}
  1198.   |   | `-Integer {46077912:0}
  1199.   |   |-<^> : <^> {The second number}
  1200.   |   | |-SecondNumber {46078084:0}
  1201.   |   | `-Integer {46077912:0}
  1202.   |   `-<^> : <^> {The answer}
  1203.   |     |-MyResult {46078284:0}
  1204.   |     `-Integer {46077912:0}
  1205.   `-begin :> ; :> end
  1206.     |-readln( :> , :> )
  1207.     | |-FirstNumber {46077844:0}
  1208.     | `-SecondNumber {46078084:0}
  1209.     |-<^> := <^>( :> , :> )
  1210.     | |-MyResult {46078284:0}
  1211.     | |-MultiplyTwoNumbers {46076256:0}
  1212.     | |-FirstNumber {46077844:0}
  1213.     | `-SecondNumber {46078084:0}
  1214.     |-writeln( :> , :> )
  1215.     | |-'The first: '
  1216.     | |-FirstNumber {46077844:0}
  1217.     | |-' The Second: '
  1218.     | |-SecondNumber {46078084:0}
  1219.     | |-' The Product: '
  1220.     | `-MyResult {46078284:0}
  1221.     `-
  1222.  
  1223. Below are the two source code files generated by the outline
  1224. above.
  1225.  
  1226. MultTwo.Pas:
  1227.  
  1228.   Program MultTwo;
  1229.     {This program reads in two numbers and prints the product}
  1230.       Uses Multiply;
  1231.       Var
  1232.         FirstNumber : Integer {The first number};
  1233.         SecondNumber : Integer {The second number};
  1234.         MyResult : Integer {The answer};
  1235.     begin
  1236.       readln(
  1237.         FirstNumber,
  1238.         SecondNumber);
  1239.       MyResult := MultiplyTwoNumbers(
  1240.         FirstNumber,
  1241.         SecondNumber);
  1242.       writeln(
  1243.         'The first: ',
  1244.         FirstNumber,
  1245.         ' The Second: ',
  1246.         SecondNumber,
  1247.         ' The Product: ',
  1248.         MyResult);
  1249.       end.
  1250.  
  1251. Multiply.pas:
  1252.  
  1253.   Unit Multiply;
  1254.     interface
  1255.       Function MultiplyTwoNumbers(OneNumber :
  1256. Integer;AnotherNumber : Integer) : Integer; 
  1257.     implementation
  1258.       Function MultiplyTwoNumbers(OneNumber :
  1259. Integer;AnotherNumber : Integer) : Integer;
  1260.         begin
  1261.           MultiplyTwoNumbers :=
  1262.             OneNumber* 
  1263.             AnotherNumber;
  1264.           end;
  1265.       begin
  1266.       end.
  1267. Command Reference
  1268.  
  1269. A user can select any menu item he sees displayed at the top of
  1270. the screen by holding down [Alt] key and the highlighted letter in
  1271. the menu choice.  If the menu is active, don't use [Alt], just use
  1272. the highlighted letter.  A user can activate the main menu by
  1273. pressing [F10].  Also, he can press [Alt-F] or [Alt-R] or [Alt-M]
  1274. or [Alt-E] or [Alt-W] or [Alt-A] to activate the main menu and the
  1275. associated submenu.  Many commands lead to dialog boxes.  When
  1276. these dialog buttons come up, they usually have the "cancel"
  1277. option highlighted.  If a user presses return, the box will go
  1278. away and no changes will be made.  If a user wants to do something
  1279. in a dialog box, he can press [Tab] to move to the first object in
  1280. the box.  Likewise, [Shift-Tab] will move him to the previous
  1281. object in the box.
  1282.  
  1283. Menu structure
  1284. The Menu Structure is:
  1285.  
  1286. Menus                               [F10]
  1287. I. File                             [Alt-F]
  1288.   A. Open                           [F3]
  1289.   B. Save                           [F2]
  1290.   C. Save As                        [F9]
  1291.   D. Change Directory               [Shift-F9]
  1292.   E. Print                          [Ctrl-PrtScr]
  1293.   F. Print to File                  [Shift-F7]
  1294.   G. Report to File                 [Ctrl-F7]
  1295.   H. Import ASCII File              [Ctrl-F8]
  1296.   I. Dos Shell
  1297.   I. Exit                           [Alt-X]
  1298. II. Relocate Items                  [Alt-R]
  1299.   A. Line to clipboard              [Shift-F1]
  1300.   B. Tree to clipboard              [Ctrl-F1]
  1301.   C. Line from clipboard            [Shift-F2]
  1302.   D. Tree from clipboard            [Ctrl-F2]
  1303.   E. Marked Lines to under current  [Shift-F3]
  1304.   F. Tree left a level              [Ctrl-Left]
  1305.   G. Tree right a level             [Ctrl-Right]
  1306.   H. Tree up                        [Ctrl-PgUp]
  1307.   I. Tree Down                      [Ctrl-PgDn]
  1308.   J. Sort
  1309.     1. Ascending                    Grey-Plus
  1310.     2. Descending                   Grey-Minus
  1311. III. Move Cursor                    [Alt-M]
  1312.   A. to child                       [F4]
  1313.   B. to parent                      [F7]
  1314.   C. to sibling                     [F8]
  1315.   D. to marked                      [Alt-J]
  1316.   E. to any report line             [Ctrl-F9]
  1317.   F. to descendant report line      [Alt-F9]
  1318.   G. Search                         [Alt-S]
  1319.   H. Go to line #                   [Alt-G]
  1320.   I. First line                     [Ctrl-Home]
  1321.   J. Last line                      [Ctrl-End]
  1322.   K. Up a line                      [Up]
  1323.   L. Down a line                    [Down]
  1324.   M. Up a screen                    [PgUp]
  1325.   N. Down a screen                  [PgDn]
  1326.   N. to basis of current
  1327. IV. Edit                            [Alt-E]
  1328.   A. Add a line
  1329.     1. as a child of current        [Ctrl-Enter]
  1330.     2. as a sibling of current      [Enter]
  1331.     3. as a parent of current       [Ctrl-F3]
  1332.     4. as the first line
  1333.   B. Copy
  1334.     1. Current line to clipboard    [Alt-C]
  1335.     2. Current tree to clipboard    [Alt-K]
  1336.     3. Marked lines to clipboard    [Shift-F4]
  1337.     4. Marked trees to clipboard    [Ctrl-F4]
  1338.   C. Delete
  1339.     1. Current line                 [Alt-D]
  1340.     2. Current tree                 [Shift-Delete]
  1341.   D. Display
  1342.     1. Hide children                [Alt-H]
  1343.     2. Show children of current     [Alt-F8]
  1344.     3. Show all children
  1345.     3. Select display style
  1346.   E. Undo                           [Esc]
  1347. V. Marking                          [Alt-A]
  1348.   A. Mark/Unmark a line             [Alt-V]
  1349.   B. Reference marked lines         [Alt-=]
  1350.   C. Unmark all lines               [Alt-U]
  1351.   D. Mark if found                  [Ctrl-F6]
  1352.   E. Search,Extract,Mark/Reference
  1353. VI. Window                          [Alt-W]
  1354.   A. Next                           [F6]
  1355.   B. Previous                       [Shift-F6]
  1356.   C. Close window                   [Alt-F3]
  1357.   D. Tile windows                   [Alt-Z]
  1358.   E. Cascade windows                [Shift-F8]
  1359.   F. Size/Move window               [Ctrl-F5]
  1360.   G. Zoom                           [F5]
  1361.   H. Open Clipboard
  1362.  
  1363. In addition, a single click of the left mouse button sets the
  1364. cursor to a line, and a double click marks or unmarks a line.
  1365.  
  1366. Description of commands
  1367.  
  1368. Edit|Add a line|As a child of current     Ctrl-Enter
  1369. Creates a new line and inserts it as a child of the current line.
  1370.  
  1371.      Script: cmAddLine
  1372.  
  1373. Edit|Add a line|As a sibling of current   Enter
  1374. Creates a new line and inserts it as a sibling of the current
  1375. line.
  1376.  
  1377.      Script: cmAddSibling
  1378.  
  1379. Edit|Add a line|as a parent of current    Ctrl-F3
  1380. Creates a new line and inserts it as the parent of the current
  1381. line.
  1382.  
  1383.      Script: cmAddBranch
  1384.  
  1385. Edit|Add a line|as the first line
  1386. Creates a new root line and inserts the old root into the new
  1387. root.
  1388.  
  1389.      Script: cmAddRoot
  1390.  
  1391. Edit|Copy|Current line to clipboard       Alt-C
  1392. Copies a line from the current window to the clip board.  The
  1393. children of the line (if any) are not copied.  If the clip board
  1394. is not open yet, EVOLVE! will open it.
  1395.  
  1396. Edit|Copy|Marked lines to clipboard       Shift-F4
  1397. Copy marked lines to the current line of the clipboard.
  1398. This command will open the clipboard if necessary.
  1399.  
  1400. Edit|Copy|Marked trees to clipboard       Ctrl-F4
  1401. Copy marked trees to the current line of the clipboard.
  1402. This command will open the clipboard if necessary.
  1403.  
  1404. Edit|Copy|Tree to clipboard               Alt-K
  1405. Copies a subtree from the current window to the clip board.
  1406. This command will open the clipboard if necessary.
  1407.  
  1408. Edit|Delete|Current line                  Alt-D
  1409. Deletes the current line from the current window.
  1410. If the line has children, the line's parent will adopt them.
  1411.  
  1412.      Script: cmDelLine
  1413.  
  1414. Edit|Delete|Current tree                  Shift-Delete
  1415. Erases the current subtree in the current window.
  1416.  
  1417.      Script: cmDelTree
  1418.  
  1419. Edit|Display|Hide children                Alt-H
  1420. Hides the children of the current line.
  1421.  
  1422.      Script: cmHideKids
  1423.  
  1424. Edit|Display|Select display style
  1425. EVOLVE! provides four styles for outlines:
  1426.  
  1427.      1. A conventional outlining style.
  1428.      2. A numbered list style.
  1429.      3. Blanks only.
  1430.      4. Line drawing characters.
  1431.  
  1432. Below are examples of the four styles.
  1433.  
  1434. Outline Title
  1435. I. First Main topic
  1436.   A. First Subtopic
  1437.     1. First sub-sub-topic
  1438.       i) Minor topic
  1439.         a) Minor point
  1440.           1) Sub-minor point
  1441.           2) Another sub minor point
  1442.         b) Another minor point
  1443.       ii) Another minor topic
  1444.     2. Second sub-sub-topic
  1445.   B. Second subtopic
  1446. II. Second main topic
  1447.  
  1448.  
  1449. Outline Title
  1450. 1. First Main topic
  1451.   1. First Subtopic
  1452.     1. First sub-sub-topic
  1453.       1. Minor topic
  1454.         1. Minor point
  1455.           1. Sub-minor point
  1456.           2. Another sub minor point
  1457.         2. Another minor point
  1458.       2. Another minor topic
  1459.     2. Second sub-sub-topic
  1460.   2. Second subtopic
  1461. 2. Second main topic
  1462.  
  1463. Outline Title
  1464.   First Main topic
  1465.     First Subtopic
  1466.       First sub-sub-topic
  1467.         Minor topic
  1468.           Minor point
  1469.             Sub-minor point
  1470.             Another sub minor point
  1471.           Another minor point
  1472.         Another minor topic
  1473.       Second sub-sub-topic
  1474.     Second subtopic
  1475.   Second main topic
  1476.  
  1477. Outline Title
  1478. |-First Main topic
  1479. | |-First Subtopic
  1480. | | |-First sub-sub-topic
  1481. | | | |-Minor topic
  1482. | | | | |-Minor point
  1483. | | | | | |-Sub-minor point
  1484. | | | | | `-Another sub minor point
  1485. | | | | `-Another minor point
  1486. | | | `-Another minor topic
  1487. | | `-Second sub-sub-topic
  1488. | `-Second subtopic
  1489. `-Second main topic
  1490.  
  1491. Edit|Display|Show all children
  1492. Shows every line of the outline.
  1493.  
  1494.      Script: cmShowAllKids
  1495.  
  1496. Edit|Display|Show children of current     Alt-F8
  1497. Shows the children of the current line.
  1498.  
  1499.      Script: cmShowKids
  1500.  
  1501. Edit|Undo                                 Esc
  1502. Undoes the changes to the current line.  This only has an effect
  1503. if the cursor has not moved off the line since the changes were
  1504. made.
  1505.  
  1506.      Script: cmUndo
  1507.  
  1508. File|Change Directory                     Shift-F9
  1509. File│Change Dir brings up the Change Directory dialog box, in
  1510. which you can change the current directory.
  1511.  
  1512. File|Dos Shell
  1513. Shells to DOS.  This allows you access to DOS without closing
  1514. EVOLVE!.  
  1515.  
  1516.      Script: cmExec
  1517.  
  1518. The script version of this command is slightly different.  It does
  1519. not shell to DOS, rather it executes each child line as a DOS
  1520. command.  When EVOLVE! executes this script command, it takes the
  1521. first word in each line and looks for an executable file of that
  1522. name.  If the first token is not the name of an executable file,
  1523. EVOLVE! attempts to execute the line through the command processor
  1524. specified by the COMSPEC environment variable.  This command
  1525. processor is usually 'command.com' which will process commands
  1526. like 'Dir.'
  1527.  
  1528. File|Exit                                 Alt-X
  1529. The Exit command terminates this program.
  1530.  
  1531. File|Import ASCII File                    Ctrl-F8
  1532. Reads an ASCII file and transforms it into an outline.  This is
  1533. the complement of Report.
  1534.  
  1535.      Script: cmTroper
  1536.  
  1537. In the script, the first child is taken as the name of the file to
  1538. import.
  1539.  
  1540. File|Open                                 F3
  1541. The Open command displays the Open a File dialog box. In this
  1542. dialog box you select the data file you want to use.
  1543.  
  1544. The "Open a File" dialog box contains:
  1545.  
  1546.  ■ an input box with a history list
  1547.  ■ a list box to browse the directory
  1548.  ■ the standard Cancel button
  1549.  ■ Open action button
  1550.  ■ an information panel that describes the
  1551.    selected file
  1552.  
  1553.      Script: cmFOpen
  1554.  
  1555. In the script, the first child is taken as the name of the file to
  1556. open.
  1557.  
  1558. File|Print                                Ctrl-PrtScr
  1559. Prints the outline in the current window.
  1560.  
  1561.      Script: cmPrint
  1562.  
  1563. File|Print to File                        Shift-F7
  1564. Prints the outline descendant from the current line to a file.
  1565.  
  1566.      Script: cmPrint2F
  1567.  
  1568. In the script, EVOLVE! takes the first child to be the name of the
  1569. file to print to.
  1570.  
  1571. File|Report to File                       Ctrl-F7
  1572. Prints a report to a file. The report is produced by processing
  1573. the outline.  The blank display style used so no line drawing
  1574. characters, roman numerals, or numbering will be put into the
  1575. report file by EVOLVE!.  EVOLVE! will look for the " :> " to
  1576. define text to print after its children.  The first " :> " starts
  1577. the string that EVOLVE! appends to the end of each terminal
  1578. descendant except the last terminal descendant.  The second " :> "
  1579. string defines the string that EVOLVE! appends to the end of the
  1580. last terminal descendant.  A terminal descendant is the last child
  1581. itself if there are no children of the last child.  Otherwise, the
  1582. terminal descendant is the terminal descendant of the last child.
  1583.  
  1584.      Script: cmReport
  1585.  
  1586. File|Save                                 F2
  1587. Saves an outline (the current line and all descendant lines) in
  1588. the current window to a data file.
  1589.  
  1590. File|Save As                              F9
  1591. Enables you to save an outline to a file name other than the one
  1592. shown as the title of the window.  The outline saved will be the
  1593. current line and all descendants.
  1594.  
  1595.      Script: cmFSaveAs
  1596.  
  1597. In the script, EVOLVE! takes the first child to be the name of the
  1598. file to save the outline to.
  1599.  
  1600. Marking|Mark if found                     Ctrl-F6
  1601. Marks the first line found that contains the substring you
  1602. specify.
  1603.  
  1604.      Script: cmMarkSearch
  1605.  
  1606. The first child of cmMarkSearch is the string it will look to
  1607. find.  The second, third and fourth children are whole numbers
  1608. indicating search options, and if any are ommited, the script
  1609. processor will consider them to be equal to zero.  The second
  1610. child indicates direction of search (0 - forward, 1 - backward). 
  1611. The third child indicates options ( 0 - none, 1 - whole words
  1612. only, 2 - Case sensitive, 3 - Whole words only and case
  1613. sensitive).  The fourth child indicates the scope of the search (0
  1614. - global, 1- local to the current line and its descendants).
  1615.  
  1616. Marking|Mark/Unmark current line          Alt-V
  1617. If the current line is unmarked, this command marks it.  If the
  1618. current line is marked, this command unmarks it.  Marked lines
  1619. form a set of lines that the user may reference at other
  1620. locations, or jump to with the 'Move cursor|Go to marked' menu
  1621. item.
  1622.  
  1623.      Script: cmMark
  1624.  
  1625. Marking|Reference marked lines            Alt-=
  1626. References all marked lines.
  1627.  
  1628.      Script: cmReference
  1629.  
  1630. Marking|Search,Extract,Mark/Reference
  1631. This command performs the following steps:
  1632.  
  1633.      1. Unmark all marks.
  1634.  
  1635.      2. Searches for the specified text and conditions.
  1636.  
  1637.      3. Asks the user to confirm marking/referencing the text
  1638.      found.
  1639.  
  1640.      4. Extracts the text from the line and replaces it with
  1641.      "<^>".
  1642.  
  1643.      5. If nothing is marked, the extracted text is inserted as a
  1644.      child and the new child is referenced.  The new child has the
  1645.      correct position to be processed by the "<^>" during a
  1646.      report.
  1647.  
  1648.      6. If something has been marked, the mark is referenced.  The
  1649.      referenced child is positioned such that it will be processed
  1650.      by the "<^>" during a report.
  1651.  
  1652. The text produced by a report after this process is identical to
  1653. the text produced before this process.
  1654.  
  1655.      Script: cmRefSearch
  1656.  
  1657. The first child of cmRefSearch is the string it will look to find. 
  1658. The second, third and fourth children are whole numbers indicating
  1659. search options, and if any are ommited, the script processor will
  1660. consider them to be equal to zero.  The second child indicates
  1661. direction of search (0 - forward, 1 - backward).  The third child
  1662. indicates options ( 0 - none, 1 - whole words only, 2 - Case
  1663. sensitive, 3 - Whole words only and case sensitive).  The fourth
  1664. child indicates the scope of the search (0 - global, 1- local to
  1665. the current line and its descendants).  The programmer may specify
  1666. additional strings to search for as the children of the first
  1667. child of the cmRefSearch.
  1668.  
  1669. Marking|Unmark all lines                  Alt-U
  1670. Unmarks all marked lines.
  1671.  
  1672.      Script: cmUnMarkAll
  1673.  
  1674. Move Cursor|Down a line                   Down
  1675. Select the line below as the current one.
  1676.  
  1677.      Script: cmMoveDown
  1678.  
  1679. Move Cursor|Down a screen                 PgDn
  1680. Moves the visible portion of the window down the height of the
  1681. window.  The command moves the cursor also to keep it visible in
  1682. the window.  
  1683.  
  1684. Move Cursor|First line                    Ctrl-Home
  1685. Goes to the first line in the outline.
  1686.  
  1687.      Script: cmFirstLine
  1688.  
  1689. Move Cursor|Go to line #                  Alt-G
  1690. Moves to the selected line number.
  1691.  
  1692.      Script: cmGoToLine
  1693.  
  1694. In the script, EVOLVE! looks for the line number at the beginning
  1695. text of the first child.
  1696.  
  1697. Move Cursor|Last line                     Ctrl-End
  1698. Goes to the last line in the outline.
  1699.  
  1700.      Script: cmLastLine
  1701.  
  1702. Move Cursor|Search                        Alt-S
  1703. Search will open a dialog box where you can enter text.  EVOLVE!
  1704. will then search in the direction you specify for the next
  1705. occurrence of that text and make that occurrence the current line.
  1706.  
  1707.      Script: cmSearch
  1708.  
  1709. The first child of cmSearch is the string it will look to find. 
  1710. The second, third and fourth children are whole numbers indicating
  1711. search options, and if any are ommited, the script processor will
  1712. consider them to be equal to zero.  The second child indicates
  1713. direction of search (0 - forward, 1 - backward).  The third child
  1714. indicates options ( 0 - none, 1 - whole words only, 2 - Case
  1715. sensitive, 3 - Whole words only and case sensitive).  The fourth
  1716. child indicates the scope of the search (0 - global, 1- local to
  1717. the current line and its descendants).
  1718.  
  1719. Move Cursor|Up a line                     Up
  1720. Selects the line above as the current line.
  1721.  
  1722.      Script: cmMoveUp
  1723.  
  1724. Move Cursor|Up a screen                   PgUp
  1725. This command moves the visible portion of the window up the height
  1726. of the window.  The command moves the cursor also to keep it
  1727. visible in the window.  
  1728.  
  1729. Move Cursor|to basis of current
  1730. Goes to the Basis.  When a line is referenced, only one instance
  1731. shows the children explicitly.  The instance that shows the
  1732. children is the basis.
  1733.  
  1734.      Script: cmGoToBasis
  1735.  
  1736. Move Cursor|to child                      F4
  1737. Select one of the current line's children as the current line.
  1738.  
  1739.      Script: cmGoToKid
  1740.  
  1741. In the script, EVOLVE! looks for the a number at the beginning of
  1742. the instruction's first child to indicate which of the current
  1743. line's children will become the next current line.  If the number
  1744. is 0 then the first child will become the current line.  In
  1745. general, if the number is N then the N+1 child will become the
  1746. current line.
  1747.  
  1748. Move Cursor|to marked                     Alt-J
  1749. Selects one of the Marked lines as the current line.  This is a
  1750. good way to see the marked lines.  The lines are shown in a
  1751. scrollable menu.  Each line begins with the line number that the
  1752. text appears at.  The text that follows the line number has the
  1753. <^> characters replaced with the appropriate text.
  1754.  
  1755.      Script: cmGoToMark
  1756.  
  1757. In the script, EVOLVE! looks for the a number at the beginning of
  1758. the instruction's first child to indicate which of the marked 
  1759. line's will become the next current line.  If the number is 0 then
  1760. the first marked line will become the current line.  In general,
  1761. if the number is N then the N+1 marked line will become the
  1762. current line.
  1763.  
  1764. Move Cursor|to parent                     F7
  1765. Selects one of the current line's parents as the current line.
  1766. This is a good way to see the parent lines.  The lines are shown
  1767. in a scrollable menu.  Each line begins with the line number that
  1768. the text appears at.  The text that follows the line number has
  1769. the <^> characters replaced with the appropriate text.
  1770.  
  1771.      Script: cmGoToParent
  1772.  
  1773. In the script, EVOLVE! looks for the a number at the beginning of
  1774. the instruction's first child to indicate which of the current
  1775. line's parents will become the next current line.  Each referenced
  1776. line will have multiple appearances and one parent per appearance. 
  1777. If the number is 0 then the first parent will become the current
  1778. line.  In general, if the number is N then the N+1 parent will
  1779. become the current line.
  1780.  
  1781.  
  1782. Move Cursor|to report line                Ctrl-F9
  1783. Displays the report text and enables you to move to the outline
  1784. entry that corresponds to the reported line.  This is a good way
  1785. to see the source code as reported.  The lines are shown in a
  1786. scrollable menu.  
  1787.  
  1788.      Script: cmGoToRepLine
  1789.  
  1790. In the script, EVOLVE! looks for the a number at the beginning of
  1791. the instruction's first child to indicate which report line will
  1792. become the next current line.  
  1793.  
  1794. Move Cursor|to descendant report line     Alt-F9           
  1795. Displays the report text and enables you to move to the outline
  1796. entry that corresponds to the reported line descendant from the
  1797. current line.  This is a good way to see the source code as
  1798. reported.  The lines are shown in a scrollable menu.  This command
  1799. is faster than 'Move Cursor| to report line' because it processes
  1800. fewer reported lines.
  1801.  
  1802.  
  1803.      Script: cmGoToDescRepLine
  1804.  
  1805. In the script, EVOLVE! looks for the a number at the beginning of
  1806. the instruction's first child to indicate which report line will
  1807. become the next current line.  
  1808.  
  1809. Move Cursor|to sibling                    F8
  1810. Selects one of the current line's siblings as the current line. 
  1811. This is a good way to see the sibling lines.  The lines are shown
  1812. in a scrollable menu.  Each line begins with the line number that
  1813. the text appears at.  The text that follows the line number has
  1814. the <^> characters replaced with the appropriate text.
  1815.  
  1816.      Script: cmGoToSibling
  1817.  
  1818. In the script, EVOLVE! looks for the a number at the beginning of
  1819. the instruction's first child to indicate which of the current
  1820. line's siblings will become the next current line.  If the number
  1821. is 0 then the first sibling will become the current line.  In
  1822. general, if the number is N then the N+1 sibling will become the
  1823. current line.
  1824.  
  1825. Relocate|Line from clipboard              Shift-F2
  1826. Takes a line from the clip board and inserts it in the current
  1827. window.  If the line has children, the line's parent will adopt
  1828. them.  If the clip board is not open yet, EVOLVE! will open it.
  1829.  
  1830. Relocate|Line to clipboard                Shift-F1
  1831. Cuts a line from the current window and inserts it in the clip
  1832. board.  If the line has children, the line's parent will adopt
  1833. them.  If the clip board is not open yet, EVOLVE! will open it.
  1834.  
  1835. Relocate|Marked lines to under current    Shift-F3
  1836. Relocates marked lines to under current.
  1837.  
  1838.      Script: cmMoveMarkedLines
  1839.  
  1840. Relocate|Sort|Ascending                   Grey-Plus
  1841. Sorts the siblings, under one branch, in ascending order.
  1842.  
  1843.      Script: cmOrderAscend
  1844.  
  1845. Relocate|Sort|Descending                  Grey-Minus
  1846. Sorts the siblings, under one branch, in descending order.
  1847.  
  1848.      Script: cmOrderDescend
  1849.  
  1850. Relocate|Tree Down                        Ctrl-PgDn
  1851. Moves the current subtree up or down by switching its position
  1852. with the sibling below.
  1853.  
  1854.      Script: cmMoveTreeDn
  1855.  
  1856. Relocate|Tree from clipboard              Ctrl-F2
  1857. Removes the current subtree from the clip board and inserts it
  1858. under the current line in the current window.
  1859.  
  1860. Relocate|Tree left a level                Ctrl-Left
  1861. Moves the current line and all its descendants such that its
  1862. grandparent becomes its new parent.
  1863.  
  1864.      Script: cmMoveTreeLeft
  1865.  
  1866. Relocate|Tree right a level               Ctrl-Right
  1867. Moves the current line and all its descendants such that its
  1868. nearest sibling above it becomes its new parent.
  1869.  
  1870.      Script: cmMoveTreeRight
  1871.  
  1872. Relocate|Tree to clipboard                Ctrl-F1
  1873. Removes a subtree from the current window and inserts it under the
  1874. current line in the clip board.  EVOLVE! opens the clip board if
  1875. it needs to do so.
  1876.  
  1877. Relocate|Tree up                          Ctrl-PgUp
  1878. Moves the current subtree up or down by switching its position
  1879. with the sibling above.
  1880.  
  1881.      Script: cmMoveTreeUp
  1882.  
  1883. Window|Cascade windows                    Shift-F8
  1884. Stacks all file viewers on the desktop.
  1885.  
  1886. Window|Close window                       Alt-F3
  1887. Closes the active window.
  1888.  
  1889. You can also click the Close box in the upper right corner to
  1890. close a window.
  1891.  
  1892. Window|Next                               F6
  1893. Cycles forwards through the windows on the desktop.
  1894.  
  1895. Window|Open Clipboard
  1896. Opens a window for the clip board.
  1897.  
  1898. Window|Previous                           Shift-F6
  1899. Cycles forwards through the windows on the desktop.
  1900.  
  1901. Window|Size/Move window                   Ctrl-F5
  1902. Changes the size or position of the active window.
  1903.  
  1904.   ====
  1905.   Size
  1906.   ====
  1907. If you press Shift while you use the arrow keys, you can change
  1908. the size of the active window. Once you've adjusted its size or
  1909. position, press Enter.
  1910.  
  1911. If a window has a Resize corner, you can drag that corner to
  1912. resize the window.
  1913.  ======
  1914.   Move
  1915.  ======
  1916. When you choose Window│Size/Move, the active window moves in
  1917. response to the arrow keys. Once you've moved a window to where
  1918. you want it, press Enter.
  1919.  
  1920. You can also move a window by dragging its title bar with the
  1921. mouse.
  1922.  
  1923. Window|Tile                               Alt-Z
  1924. Tiles all windows on the desktop.
  1925.  
  1926. Window|Zoom                               F5
  1927. Resizes the active window to the maximum size. If the window is
  1928. already zoomed, you can choose this command to restore it to its
  1929. previous size.
  1930.  
  1931. You can also double-click anywhere on the window's title bar
  1932. (except where an icon appears) to zoom or unzoom the window.
  1933. Menu items sorted by hotkey
  1934. ===========================
  1935.  
  1936. Menu Item                                 HotKey
  1937. ----------------------------------------  ---------------
  1938. Edit|Add a line|as the first line
  1939. Edit|Display|Select display style
  1940. Move Cursor|to basis of current
  1941. Window|Open Clipboard
  1942. Marking|Reference marked lines            Alt-=
  1943. Edit|Copy|Current line to clipboard       Alt-C
  1944. Edit|Delete|Current line                  Alt-D
  1945. Window|Close window                       Alt-F3
  1946. Edit|Display|Show children of current     Alt-F8
  1947. Move Cursor|to descendant report line     Alt-F9
  1948. Execute as script program                 Alt-F10
  1949. Move Cursor|Go to line #                  Alt-G
  1950. Edit|Display|Hide children                Alt-H
  1951. Move Cursor|to marked                     Alt-J
  1952. Edit|Copy|Tree to clipboard               Alt-K
  1953. Move Cursor|Search                        Alt-S
  1954. Marking|Mark/Unmark current line          Alt-V
  1955. Marking|Unmark all lines                  Alt-U
  1956. File|Exit                                 Alt-X
  1957. Window|Tile                               Alt-Z
  1958. Move Cursor|Last line                     Ctrl-End
  1959. Edit|Add a line|As a child of current     Ctrl-Enter
  1960. Relocate|Tree to clipboard                Ctrl-F1
  1961. Relocate|Tree from clipboard              Ctrl-F2
  1962. Edit|Add a line|as a parent of current    Ctrl-F3
  1963. Edit|Copy|Marked trees to clipboard       Ctrl-F4
  1964. Window|Size/Move window                   Ctrl-F5
  1965. Marking|Mark if found                     Ctrl-F6
  1966. File|Report to file                       Ctrl-F7
  1967. File|Import ASCII file                    Ctrl-F8
  1968. Move cursor|to report line                Ctrl-F9
  1969. Move cursor|First line                    Ctrl-Home
  1970. Relocate|Tree left a level                Ctrl-Left
  1971. Relocate|Tree down                        Ctrl-PgDn
  1972. Relocate|Tree up                          Ctrl-PgUp
  1973. File|Print                                Ctrl-PrtSc
  1974. Relocate|Tree right a level               Ctrl-Right
  1975. Move cursor|Down a line                   Down
  1976. Edit|Add a line|As a sibling of current   Enter
  1977. Edit|Undo                                 Esc
  1978. File|Save                                 F2
  1979. File|Open                                 F3
  1980. Move cursor|To child                      F4
  1981. Window|Zoom                               F5
  1982. Window|Next                               F6
  1983. Move cursor|To parent                     F7
  1984. Move cursor|To sibling                    F8
  1985. File|Save As                              F9
  1986. Relocate|Sort|Descending                  Grey-Minus
  1987. Relocate|Sort|Ascending                   Grey-Plus
  1988. Move cursor|Down a screen                 PgDn
  1989. Move cursor|Up a screen                   PgUp
  1990. Edit|Delete|Current tree                  Shift-Delete
  1991. Relocate|Line to clipboard                Shift-F1
  1992. Relocate|Line from clipboard              Shift-F2
  1993. Relocate|Marked lines to under current    Shift-F3
  1994. Edit|Copy|Marked lines to clipboard       Shift-F4
  1995. Window|Previous                           Shift-F6
  1996. File|Print to file                        Shift-F7
  1997. Window|Cascade windows                    Shift-F8
  1998. File|Change directory                     Shift-F9
  1999. Move cursor|Up a line                     Up
  2000. License Agreement
  2001.  
  2002. Richard H. Smith
  2003. 7040 Wick Lane
  2004. Derwood, MD 20855
  2005. (301) 977-4166
  2006.  
  2007. Please use copy, and distribute EVOLVE!.  This program is
  2008. distributed as Shareware.  
  2009.  
  2010. Definition of Shareware
  2011.  
  2012. Shareware distribution gives users a chance to try software before
  2013. buying it. If you try a Shareware program and continue using it,
  2014. you are expected to register. Individual programs differ on
  2015. details -- some request registration while others require it, some
  2016. specify a maximum trial period. With registration, you get
  2017. anything from the simple right to continue using the software to
  2018. an updated program with printed manual. 
  2019.  
  2020. Copyright laws apply to both Shareware and commercial software,
  2021. and the copyright holder retains all rights, with a few specific
  2022. exceptions as stated below. Shareware authors are accomplished
  2023. programmers, just like commercial authors, and the programs are of
  2024. comparable quality. (In both cases, there are good programs and
  2025. bad ones!) The main difference is in the method of distribution.
  2026. The author specifically grants the right to copy and distribute
  2027. the software, either to all and sundry or to a specific group. For
  2028. example, some authors require written permission before a
  2029. commercial disk vendor may copy their Shareware.
  2030.  
  2031. Shareware is a distribution method, not a type of software. You
  2032. should find software that suits your needs and pocketbook, whether
  2033. it's commercial or Shareware. The Shareware system makes fitting
  2034. your needs easier, because you can try before you buy. And because
  2035. the overhead is low, prices are low also. Shareware has the
  2036. ultimate money-back guarantee -- if you don't use the product, you
  2037. don't pay for it.
  2038.  
  2039. Disclaimer - Agreement
  2040.  
  2041. Users of EVOLVE! must accept this disclaimer of warranty: "EVOLVE!
  2042. is supplied as is.  The author disclaims all warranties, expressed
  2043. or implied, including, without limitation, the warranties of
  2044. merchantability and of fitness for any purpose.
  2045.  
  2046. The author assumes no liability for damages, direct or 
  2047. consequential, which may result from the use of EVOLVE!. EVOLVE!
  2048. is a "shareware program" and is provided at no charge to the user
  2049. for evaluation.  Feel free to share it with your friends, but
  2050. please do not give it away altered or as part of another system. 
  2051. The essence of "user-supported" software is to provide personal
  2052. computer users with quality software without high prices, and yet
  2053. to provide incentive for programmers to continue to develop new
  2054. products.  If you find this program useful and find that you are
  2055. using EVOLVE! and continue to use EVOLVE! after a reasonable trial
  2056. period, you must make a registration payment of $29.00 plus $5.00
  2057. shipping and handling to Software Smiths.  The $29.00 registration
  2058. fee will license one copy for use on any one computer at any one
  2059. time.  If you find value in EVOLVE! but can not afford the $29.00,
  2060. you may obtain a low priority registration by sending me a letter
  2061. telling me that you can not afford to pay the $29.00 fee now, but
  2062. that you intend to pay it in the future when you can afford it. 
  2063. You must treat this software just like a book.  An example is that
  2064. this software may be used by any number of people and may be
  2065. freely moved from one computer location to another, so long as
  2066. there is no possibility of it being used at one location while
  2067. it's being used at another.  Just as a book cannot be read by two
  2068. different persons at the same time.  The $5.00 shipping and
  2069. handling will pay for material Software Smiths will mail to you
  2070. upon registration.
  2071.  
  2072. Commercial users of EVOLVE! must register and pay for their copies
  2073. of EVOLVE! within 30 days of first use or their license is
  2074. withdrawn.  Site-License arrangements may be made by contacting
  2075. Software Smiths.
  2076.  
  2077. Anyone distributing EVOLVE! for any kind of remuneration must
  2078. first contact Software Smiths at the address at the beginning of
  2079. this appendix for authorization.  This authorization will be
  2080. automatically granted to distributors recognized by the (ASP) as
  2081. adhering to its guidelines for shareware distributors, and such
  2082. distributors may begin offering EVOLVE! immediately (However
  2083. Software Smiths must still be advised so that the distributor can
  2084. be kept up-to-date with the latest version of EVOLVE!.).
  2085.  
  2086. You are encouraged to pass a copy of EVOLVE! along to your friends
  2087. for evaluation.  Please encourage them to register their copy if
  2088. they find that they can use it.  All registered users will receive
  2089. a copy of the latest version of the EVOLVE! system.
  2090.  
  2091. Benefits of registering
  2092.  
  2093. Software Smiths will provide the following 
  2094.  
  2095.      1. If you register as a user and pay $5.00 shipping and
  2096.      handling, Software Smiths will send you the next version of
  2097.      EVOLVE!.  Your registration will apply to this version mailed
  2098.      directly to you.
  2099.  
  2100.      2. The registered version of the software will not have a
  2101.      registration notice at the start up.
  2102.  
  2103.      3. Software Smiths will send you a printed user's guide.
  2104.  
  2105.      4. Software Smiths will notify you of any significant bugs
  2106.      found.
  2107.  
  2108.      5. Software Smiths will extend to you the first opportunity
  2109.      to purchase related programs.  We currently plan to develop
  2110.      versions for OS/2 and Microsoft Windows.
  2111.  
  2112.      6. Software Smiths will incorporate your ideas and feedback
  2113.      into the continued development of their products.
  2114.  
  2115.      7. You may call or write to Software Smiths about any problem
  2116.      you have with EVOLVE! and we will do our best to remedy the
  2117.      situation.
  2118.  
  2119. How To Register
  2120.  
  2121. To register, use a text editor to fill out the form in the file
  2122. "REGISTER.DOC".  This form is shown on the next page:
  2123.  
  2124.                         Registration Form
  2125. Mail to:  Richard H. Smith
  2126.           Software Smiths
  2127.           7040 Wick Lane
  2128.           Derwood, MD 20855-1963
  2129.  
  2130. Name:
  2131. Address:
  2132. City:               State:         Zip code:
  2133.  
  2134. Product Name:                       Version:          Release:
  2135. What is your occupation?
  2136.  
  2137. What do you use this software for?
  2138.  
  2139. What do you like most about our software?
  2140.  
  2141. What do you like least about our software?
  2142.  
  2143. What do you like most about our documentation?
  2144.  
  2145. What do you like least about our documentation?
  2146.  
  2147. What is the hardware configuration off your computer?
  2148.      CPU: [] 8088   [] 80286       [] 80386       [] 80486
  2149.      Size Hard Disk:               Type of Modem:
  2150.      3 1/2" Disk Drive []          5 1/4" Disk Drive []
  2151.  
  2152. What type of software do you use?
  2153.      Operating System:
  2154.      Graphical user interface:
  2155.      Programming Languages:
  2156.  
  2157. Where did you get our software from?
  2158.  
  2159. Check one:
  2160.      [] I have enclosed a check that includes the $29.00
  2161.         registration fee.
  2162.      [] I can not afford the $29.00 now, but I will pay it when I  
  2163.       can.
  2164. Check one:
  2165.      [] I have enclosed a check that includes the $5.00 shipping
  2166.         and handling fee.
  2167.      [] I do not want Software Smiths to mail me anything.
  2168.  
  2169. ASP Ombudsman Statement
  2170.  
  2171. This program is produced by a member of the Association of
  2172. Shareware Professionals (ASP).  ASP wants to make sure that the
  2173. shareware principle works for you. If you are unable to resolve a
  2174. shareware-related problem with an ASP member by contacting the
  2175. member directly, ASP may be able to help. The ASP Ombudsman can
  2176. help you resolve a dispute or problem with an ASP member, but does
  2177. not provide technical support for members' products.  Please write
  2178. to the ASP Ombudsman at 545 Grover Road, Muskegon, MI 49442 or
  2179. send a CompuServe message via CompuServe Mail to ASP Ombudsman
  2180. 70007,3536.
  2181. About the Author
  2182.  
  2183. Richard H. Smith, 7040 Wick Lane, Derwood, MD 20855 
  2184. (301) 977-4166
  2185.  
  2186. Objective: An opportunity to perform systems analysis, software
  2187. engineering and training.
  2188.  
  2189. Operating Systems: MS-DOS, UNIX, VMS.
  2190.  
  2191. Languages: Pascal, Prolog, Oracle, SQL-Plus, SLAM-II
  2192.  
  2193. Applications: Wordperfect, Lotus 123, Lotus Freelance, Corel
  2194. Draw.
  2195.  
  2196. Hardware: IBM-PC, Unisys, Vax.
  2197.  
  2198. Professional Experience:
  2199.  
  2200. February 1991 - Present: Self Employed.  Developed "EVOLVE!" a
  2201. structure editor that empowers programmers to implement source
  2202. code changes more efficiently than a text editor.  This structure
  2203. editor can produce source code in any language.  
  2204.  
  2205. June 1988-February 1991: Research Analyst and Software Engineer,
  2206. Analytic Services Inc.  Systems Analyst, software engineer, and
  2207. instructor for the following products:
  2208.  
  2209.      Integrated SCOPE-MARGI (ISM).  Used structured analysis and
  2210.      structured design to integrate two decision support systems
  2211.      (SCOPE & MARGI).  Designed and developed a new capability for
  2212.      ISM that uses an event driven, object oriented user
  2213.      interface.
  2214.  
  2215.      Material Handling Equipment Decision Support System
  2216.      (MHE-DSS).  Used structured analysis and structured design to
  2217.      develop this program for calculating the performance of MHE,
  2218.      and the Air Forces requirements for MHE.  I coded the MHE-DSS
  2219.      in Pascal.  The knowledgebase in the MHE-DSS was derived from
  2220.      a simulation I coded in SLAM-II.
  2221.  
  2222.      Joint Service Research, Development and Acquisition Plan  
  2223.      management information system.  I coded this in Oracle and
  2224.      SQL-Plus on a Unisys 5000.
  2225.  
  2226.      Method for analyzing Reliability Goals and Investments
  2227.      (MARGI), a decision support system for calculating the
  2228.      benefits in combat capability from aircraft reliability
  2229.      improvements.  Used structured analysis and structured design
  2230.      to develop.  Written in Turbo Pascal and Turbo Prolog.
  2231.  
  2232. October 1984-June 1988 Acquisition Program Manager, United States
  2233. Air Force Tactical Reconnaissance System Program Office.  Managed
  2234. the development and acquisition of tactical reconnaissance
  2235. systems.
  2236.  
  2237. Education: B.S. Engineering Physics, 1984, University of Colorado
  2238. at Boulder.
  2239.  
  2240.